Don't add padding to a pointer

Fix a regression in RTL flipping

This was only showing up with pack-end packing in horizontal boxes.
The RTL flipping has to be applied after moving the reference point
to the left edge of the child.

Formatting and typo fixes

Renamed testextendedlayout2 --> extendedlayoutexample, also removed testextendedlayout and letting it reside for now in native-layout branch.

Mega commit backing out everything from the native-layout branch that
is not ready for integration

This commit makes the native-layout branch into a reasonable
patch applicable to git master, it pulls out GtkCellRenderer
support, ComboBox support, the Plug/Socket api is also not ready
and is pulled out.

Added documentation, implemented gtk_extended_layout_is_height_for_width() where needed.

Improved legibility of the label parameters test.

Added test reflecting the usage of GtkLabel parameters.

Updated test for api change.

Updating test for api change.

Make sure not to base the minimum size on "max-width-chars", only the natural size.

Added test to demonstrate width-for-height labels.

Fixed GtkLabel to wrap correctly and report width-for-height correctly when vertical.

Slightly reduced extended layout cache size, updated authors/copywrite year.

Fixed GtkLabel to include GtkMisc padding when calculating height-for-width.

Restore layout in get_desired_size() after guessing a wrap width

This fixes the label layout in cases where gtk_widget_size_request()
is called on a label without a following size_allocate(), for instance
when a button state changes.

Various updates to follow new gtk_extended_layout_get_desired_size added argument.

Fixed missing return from get_desired_width/height in GtkViewport (causing testgtk to have a small width).

Split up width and height queries so that they make more sense (extended-layout)

Added request_natural argument to get_desired_size()

Currently get_desired_size() is more of an emulation of
gtk_widget_size_request() for the minimum size as it bases the
contextual request on the minimum preferred size; this argument
lets you do the request with the natural preferred size as well.

GtkAlignment now tries to allocate natural size to the child if available and does the height-for-width calculation depending on allocation.

Fixed acces of child->requisition; call gtk_widget_get_child_requisition instead.

This fixes squished pathbar issue (as access to ->requisition is really
not supported anymore).

Reduced natural request padding for rotating ellipsizing labels

After fixing height requests this works much smoother, although in
some places pango seems to ellipsize a rotated label when given
the width it requested.

Fixed another caching bug in extended layout

Was confusing width/height REQUEST_NEEDED flags, this caused
the volumebutton test to not re-request the height properly
when changing orientations.

Unconditionally return the height for the minimum width when doing get_desired_height()

This is the correct support for the opposing orientation for widgets
that support height-for-width, in an interface that was realized as
width-for-height, a height-for-width supporting widget should return
the minimum height for the minimum width when the initial
get_desired_height() is run.

Fixed height-for-width cache

Fixed the cache to be cleared when flagged with WIDTH/HEIGHT_REQUEST_NEEDED.
This error was causing some widgets to not be sized correctly (the stock and
icon browser in the demo for instance).

Removing old comments in gtkbin.c

Fixed computation of sizegroups when no explicit request is set.

My previous commit to GtkSizeGroup made sure that when
gtk_widget_set_size_request() is set on a widget, it will be
taken into account when computing the widget's own request,
this commit fixes the case where there is no explicit size
request.

Fixed testellipsize

Added testextendedlayout2.c to tests.

This test is a collection of builder files which demonstrate the
added features of natural sizes and height-for-width geometry; so
far it only contains 3 cases, more to come...

Fixed GtkSpinner to request 12x12 at init time instead of at expose time.

This should not change the space taken by the spinner when hidden,
and it should only set the minimum size not the actual size (i.e. code
in place was conditionally setting it if not allocated 12x12, which
doesnt really make sense)... This fixes spinners showing at the correct size
in gtk-demo.

Fixed _gtk_size_group_bump_requisition() to properly handle values specified by gtk_widget_set_size_request()

Added GTK_DEBUG_EXTENDED_LAYOUT flag and use that for debuggin in gtkextendedlayout.c

Implemented GtkExtendedLayout on GtkWindow.

Fixed GtkAssistant to not access ->requisition of children directly.

This was causing a 0 height action-area because a GtkBox does not
generally update ->requisition with anything useful
(call gtk_widget_get_child_requisition() here instead).

Further fixed base outputs of GtkLabel desired geometries.

Now (when wrapping), if no "width-chars" was specified for a minimum
width, default to the width guessed by gtk_label_ensure_layout(), small
specified widths will otherwise result in very large height requests.

Fixed bug in gtk_extended_get_desired_size().

gtk_extended_get_desired_size() was mixing up orientations based
on the preference, considering ditching the preference anyway.
Also slightly enhanced debug prints.

Compute the collective heights for the width of a horizontal box.

Introduce an algorithm to allocate children some virtual widths based on
their base widths returned by ->get_desired_width(), then return the
collective desired heights for each or thier virtually allocated width.

This will only work in the horizontal orientation.

Fixed extended layout test to compile without the gtk_label_set_fullsize() api.

Restore functionality where ellipsizing label *minimum* size grows to "max-char-width".

Fixed GtkLabel reported minimum and natural sizes

This commit makes GtkLabel use "max-width-chars" to determine the
desired natural width for wrapping labels as well as all around refactoring
the initially reported values in get_desired_width/height. this also
addresses some issues with rotating ellipsizing text.

Now gtk_extended_layout_get_desired_size() returns a minimum for minimum in the minimum requisition and a natural for minimum in the natural.

Make GtkWindow use the generic smallest size for the requisition again

Fixed test to call the extended layout api instead of consulting ->requisition

Fixed GtkExtendedLayout interaction with sizegroups plus cleanups

Fixed GtkExtendedLayout to interact with sizegroups, "size-requsts"
and caching the values all in the same code segment.

Migrated the cache code to be internal to gtkextendedlayout.c

Disabling natural sizes of labels.

Since GtkLabel is returning invalid natural sizes for now,
in order to test regressions well with the new width-for-height
api, I've temporarily disabled the natural values.

Refactored GtkSizeGroup for GtkExtendedLayout

Removed _gtk_size_group_compute_requisition and
_gtk_size_group_get_child_requisition in favor of
_gtk_size_group_bump_requisition() which does an orientation
contextual computation of the size group and returns the
collective value in one pass.

Added _gtk_size_group_bump_requisition()

Added a function to update sizegroups in multiple passes, this
way the width and height can be updated in the sizegroups after
querying the extended layout implementor for these.

Implemented this in GtkExtendedLayout, sizegroups should be working reasonably now.

Mega commit to change ->get_desired_size() for ->get_desired_width/height().

This commit changes gtk_extended_layout_get_desired_size() for
per dimension variants. Furthermore this commit reverts the actions
done in size-groups for now as it needs a different approach.

The natural width/height parameters added to aux_info have been changed
for a per width cache for heights and a per height cache for widths.

gtk-demo is still working, currently sizegroups are not taken
into account as mentioned above - size groups need to be alerted both
when the widths and heights are updated independantly and then that
information needs to repropagate also to other extended layout implementors.

Constrain the window to the minimum width for the natural height

GtkWindow now requests the minimum width for the natural height
of its child, or the opposite; depending on ->get_height_for_width.
Currently its not done for GTK_WINDOW_POPUP windows as the menushells
aren't working right yet.

Implemented gtk_extended_layout_is_height_for_width() and added another guess algorithm

This patch adds another commented algorythm to find the collective
minimum and natural height for a said width of a horizontally oriented
box (or the opposite). The algorithm works quite well and can be optimized
a bit more - currently its commented because GtkLabel cannot effectively
do width-for-height calculations (doh).

Further, this patch returns an is_height_for_width() preference depending
on the boxes orientation (vertical boxes are width-for-height).

Fixed gtkbin.c:parent_extended_layout_iface to be static.

Added gtk_extended_layout_is_height_for_width()

Added an indicator telling whether a widget prefers to be allocated
as height-for-width or width-for-height. Usually this depends on the
orientation of a container or the nature of a content widget like GtkLabel.

This indicator is only used in the seldom case where a parent is allocating
free space to the child and the child can flow in either direction, GtkWindow
and GtkScrolledWindow are users of this api.

Fixed warnings due to missing GTK_WIDGET (cellview) casting.

Fixed wrapping labels to show up correctly aligned inside their allocations.

Adding tests ported over from the old branch by Matthias.

Added get_height_for_width/get_width_for_height implementation to GtkBox.

In order for natural size information to cascade correctly up through
the ancestry GtkBox needs to report height-for-width and width-for-height,
this patch includes an implementation for both in both orientations, one
of them is commented for now as its much too cpu intensive to actually use.

Fixing height-for-width wrapping of GtkLabel

Merged in fixes from the old branch in a patch prepared by Matthias Clasen,
added some fixes of my own to make sure that label wrapping follows allocation
and not requisition at show time (allocate time).

Reimplemented GtkExtendedLayout on GtkBin

Instead of implementing ->get_desired_size() on GtkBin, which
cant really be done because border widths are in the domain of
the concrete subclasses; here we implement only the get_height_for_width
and get_width_for_height apis - GtkBin subclasses whom might have a
variable border width depending on allocations need to write their
own height-for-width implementations.

Fixed regression in GtkImage size requests

Fixed gtksizegroup.c:do_size_request() to never force an initial requisition
as some widgets expect it to remain unchanged across resizes (GtkImage
with pixbufs/filenames assigned is one of these cases).

Fixed gtk_box_size_allocate() for homogeneous boxes

gtk_box_size_allocate() was forgetting to fetch the minimum
size for children when allocating in homogeneous mode and then
accessing the uninitialized allocated values in that case, fixed.

Implemented GtkExtendedLayout on GtkComboBox.

With this commit it is possible to use ellipsizing text
in the combobox's cell renderers and have them desire to
expand to natural size when placed in a GtkBox.

Deprecated gtk_widget_size_request and gtk_widget_get_child_requisition()

Ever since size groups gtk_widget_size_request() can be used in place
of gtk_widget_get_child_requisition(), deprecating both now in favor
of gtk_extended_layout_get_desired_size().

Added assertions

Added assersions that gtk_extended_layout_get_height_for_width()
methods return minimum sizes lesser than the natural size.

Simplified code in GtkSizeGroup, fixes minimum natural size.

collapse get_fast_child_requisition && get_fast_natural_size into
a single get_fast_size() function which uses the possibly hard coded
minimum request as a minimum value for the returned desired size
(this fixes cases where widgets unwarily return height-for-width
with minimum size > natural size).

Added gtk_cell_view_get_size_of_row() to gtk.symbols

GtkCellView refactoring for extended layout

Added gtk_cell_view_get_desired_size_of_row() to report full
extended layout information for a said row, this obsoletes
gtk_cell_view_get_size_of_row(). Also make GtkCellView queue
a resize on itself when cell renderers are added/removed.

Some extended layout fixes for GtkCellView

Fixed GtkCellView to use the new GtkExtendedCell interface to get
natural size from cells and factored out the old size_request() method.

Implement GtkExtendedLayout on GtkButton

GtkButton as a content type of widget needs to forward natural size information
to parent containers in order to be resized naturally.

Implement GtkExtendedLayout on Alignment

GtkAlignment is already using the height for width api to align
the child in the cases where space is available, but also needed
to implement the extended layout in order to reflect natural sizes
to parent widgets.

Implemented GtkExtendedLayout on GtkViewport

Implement GtkExtendedCell on GtkCellRendererText

Use new gtk_tree_view_column_get_desired_size()

Added gtk_tree_view_column_get_desired_size() as its a corner case
that does not fall under the two categories.

Added GtkExtendedCell interface (last commit)

Add new GtkExtendedCell interface

Added a new interface to extend layout information of GtkCellRenderers,
GtkCellRenderer is a prerequisite of GtkExtendedCellIface and provides
a base implementation of ->get_desired_size() with ->get_size().

Note that the api for GtkExtendedCell differs from GtkExtendedLayout
since the cells need to be passed an additional widget to calculate
sizes contextual to the widget/screen (fonts etc).

Remove gtk_widget_get_desired_size()

Fixed classes to call gtk_extended_layout_get_desired_size_again()

The previous patch removes the ambiguous gtk_widget_get_desired_size().

Call the ->get_desired_size() method directly on the vtable

This commit is a mistake, it should have been included with the last
commit.

Make GtkWidget a prerequisite of extended layout

As it is not allowed to called gtk_extended_layout_get_desired_size()
on a GtkWidget directly; gtk_widget_get_desired_size() was really an
ambiguous api. This patch removes the added GtkWidget api, calls
the appropriate sizegroup code which in turn envokes the interface
vtable, this patch also accordingly makes GtkWidget a prerequisite
of GtkExtendedLayout (the api doesnt work for cell renderers anyway,
patch comming...).

Revert "Implement extended layout for GtkBin"

This reverts commit 5e8045b14dde691fef5447b7ca483d95f9132b8a.

Conflicts:

gtk/gtkbin.c

Fixed 2 bugs in gtk_box_size_allocate()

This commit fixes the loop to take into consideration the
child->padding that will be allocated to the child while calculating
full available size. Additionally it fixes the initial positioning
of child widgets when packed at the end (a special case because the
x position used starts from the end of the box).

Fixed do_size_request() to start with a 0 base requisition instead of -1

Changed initial values for requisition from -1 to 0.

When doing size-requests and get_natural_size() calls, use 0 as
the base value instead of -1, because size_request code assumes
that widget->requesition is initialized at 0.

Fixed GtkBox to not call get_desired_size() on a child when no child is present.

Making function private in gtktreeviewcolumn to pass the abi test.

Refixed merge conflicts for GTK_WIDGET_MAPPED/GTK_WIDGET_VISIBLE

Fixed internal native layout algorythm wrt size-request singals/implementations.

Because "size-request" signal can be handled by signal connections as well
as by third party derived classes it is necessary to always fire the
"size-request" signal for every recalculation of the widget requisition,
now gtksizegroup.c:do_size_request() fires the signal first and allows it
to overflow the minimum/natural sizes returned by extended layout
implementations.

GtkWidget->get_natural_size() is now left assigning default -1 values to
ensure they both get overridden by the size-request handling.

Fixed extended layout implementors to not call ->get_desired_size() directly

Getting the desired size of a GtkWidget must always be done with
gtk_widget_get_desired_size() and never with
gtk_extended_layout_get_desired_size() directly as the former passes
through size group logic and updates the widget->requisition cache.

Removed casing of GTK_IS_EXTENDED_LAYOUT() from GtkViewport.

Fixed invalid pointer access in gtk_tree_view_column_get_desired_size()

Partially fixed GtkTreeview for extended layout

Removed the size_request() handling on the class and calculate
minimum size from get_desired_size(); base the natural width on
either the minimum of column headers, or a greater natural request
of the columns renderers.

Applied Jan Arne Petersen's patch for GtkScrolledWindow

Applied patch to add height-for-width/width-for-height suppot
to GtkScrolledWindow plus modifications to use gtk_widget_get_desired_size()
to query children sized instead of directly calling the layout api, plus
removed the ->size_request() implementation interfering with the mess.

Fixed GtkCellRendererText invalid pointer access.

Fixed get_desired_size() to not access parameters when NULL and
also not to access priv->object if it hasnt yet been assigned.

Take extended layout into account in viewport

Make sure the right height is used in GtkViewPort.

Don't use gio-unix on win32

We only need gio-unix when building the x11 backend.
Reported by Yevgen Muntyan in bug 614540.

Updated Basque language

Updated Basque language

Updated Basque language

Updated Danish translation